program Stringek_Kodolasa;

function XORRORString(const S: String; XORByte, RORBit: Byte): String; Assembler;
asm
  push es {Elmenti az ES regisztert a Stack-ben}
  push ds {Elmenti az DS regisztert a Stack-ben}
  push di {Elmenti az DI regisztert a Stack-ben}
  push si {Elmenti az SI regisztert a Stack-ben}
  lds  si, S       {Betlti a DS, SI regiszterprba az S String memria cmt}
  les  di, @Result {Betlti a ES, DI regiszterprba az @Result String memria cmt
                     ebben a - @Result - vltozban addik vissza a fggvny visszatrse}

  xor  ch, ch      {kinullzza a CH regisztert. (olyan mint: mov ch, 00h)         }
  mov  cl, Byte Ptr ds:[si] {Betlti a CL regiszterbe az S String hosszt, S[0]-t }
  mov  bx, cx               {Elmenti az S String hosszt BX reg.ben, a ksbbiekre}
  cld        {a REP MOVSB 'msol mvelet'-hez belltja a Direction flag-ot.     }
  inc  cl    {Nveli a CL reg.t, mert a REP MOVSB-vel tmsoljuk a ES:DI cmre              }
             { DS:SI-n kezdd S String-et. s azrt nveltk eggyel a CL-t, mert nem csak a}
  rep  movsb { a String x db. karaktert msoljuk t, hanem a String hosszt is. S[0]-t is !}
  dec  di    {Cskkenti DI reg.t, mert a REP MOVSB a msols vgn, az eredeti ES:DI-t a String
               vgre - Length(S)+1 - lltotta Pascal-osan gy: ES:=Seg(S); DI:=Ofs(S)+Length(S)+1;}
  mov  ch, XORByte {CH reg.be tlti azt a szmot amivel XOR-ozni fogunk}
  mov  cl, RORBit  {CL reg.be tlti azt a szmot amennyi bit-tel jobbra forgatjuk a String karaktert}
@Codeing:          {ide ugrik vissza a kdols sorn az algoritmus}
  xor  Byte Ptr es:[di], ch {1: meg-XOR-ozza az ES:DI-n lv karaktert CH-val (XORByte-tal)}
  xor  Byte Ptr es:[di], bl {2: meg-XOR-ozza az ES:DI-n lv karaktert BL-lel a String-ben lv pozcival}
  ror  Byte Ptr es:[di], cl {3: ROR-olja az ES:DI-n lv karaktert CL bit-tel - jobbra -   }
  dec  di {Cskkenti a DI-t, s BL-t eggyel, mert a String-ben visszafel csinljuk a kdolst, valahogy  }
  dec  bl { gy: BL:=Length(S); S[BL]:=kdolt(S[BL]); (formakplet, nem utasts !)        }
  cmp  bl, 00h  {Vizsglat: elrtk -e a String elejt ? Azaz a BL a kezdeti - BL:=Length(S) - rtkt    }
  jne  @Codeing { a kdodls sorn cskkentve elrtk -e a 0-t ?            }
  pop  si {Kiemeli a Stack-bl az SI regisztert, amint az elejn lementettk}
  pop  di {Kiemeli a Stack-bl az DI regisztert, amint az elejn lementettk}
  pop  ds {Kiemeli a Stack-bl az DS regisztert, amint az elejn lementettk}
  pop  es {Kiemeli a Stack-bl az ES regisztert, amint az elejn lementettk}
end;

function RORXORString(const S: String; XORByte, RORBit: Byte): String; Assembler;
asm
  push es {Elmenti az ES regisztert a Stack-ben}
  push ds {Elmenti az DS regisztert a Stack-ben}
  push di {Elmenti az DI regisztert a Stack-ben}
  push si {Elmenti az SI regisztert a Stack-ben}
  lds  si, S       {Betlti a DS, SI regiszterprba az S String memria cmt}
  les  di, @Result {Betlti a ES, DI regiszterprba az @Result String memria cmt
                     ebben a - @Result - vltozban addik vissza a fggvny visszatrse}

  xor  ch, ch      {kinullzza a CH regisztert. (olyan mint: mov ch, 00h)         }
  mov  cl, Byte Ptr ds:[si] {Betlti a CL regiszterbe az S String hosszt, S[0]-t }
  mov  bx, cx               {Elmenti az S String hosszt BX reg.ben, a ksbbiekre}
  cld        {a REP MOVSB 'msol mvelet'-hez belltja a Direction flag-ot.     }
  inc  cl    {Nveli a CL reg.t, mert a REP MOVSB-vel tmsoljuk a ES:DI cmre              }
             { DS:SI-n kezdd S String-et. s azrt nveltk eggyel a CL-t, mert nem csak a}
  rep  movsb { a String x db. karaktert msoljuk t, hanem a String hosszt is. S[0]-t is !}
  dec  di    {Cskkenti DI reg.t, mert a REP MOVSB a msols vgn, az eredeti ES:DI-t a String
               vgre - Length(S)+1 - lltotta Pascal-osan gy: ES:=Seg(S); DI:=Ofs(S)+Length(S)+1;}
  mov  ch, XORByte {CH reg.be tlti azt a szmot amivel XOR-ozni fogunk}
  mov  cl, RORBit  {CL reg.be tlti azt a szmot amennyi bit-tel jobbra forgatjuk a String karaktert}
@Codeing:          {ide ugrik vissza a kdols sorn az algoritmus}
  ror  Byte Ptr es:[di], cl {3: ROR-olja az ES:DI-n lv karaktert CL bit-tel - jobbra -   }
  xor  Byte Ptr es:[di], bl {2: meg-XOR-ozza az ES:DI-n lv karaktert BL-lel a String-ben lv pozcival}
  xor  Byte Ptr es:[di], ch {1: meg-XOR-ozza az ES:DI-n lv karaktert CH-val (XORByte-tal)}
  dec  di {Cskkenti a DI-t, s BL-t eggyel, mert a String-ben visszafel csinljuk a kdolst, valahogy  }
  dec  bl { gy: BL:=Length(S); S[BL]:=kdolt(S[BL]); (formakplet, nem utasts !)        }
  cmp  bl, 00h  {Vizsglat: elrtk -e a String elejt ? Azaz a BL a kezdeti - BL:=Length(S) - rtkt    }
  jne  @Codeing { a kdodls sorn cskkentve elrtk -e a 0-t ?            }
  pop  si {Kiemeli a Stack-bl az SI regisztert, amint az elejn lementettk}
  pop  di {Kiemeli a Stack-bl az DI regisztert, amint az elejn lementettk}
  pop  ds {Kiemeli a Stack-bl az DS regisztert, amint az elejn lementettk}
  pop  es {Kiemeli a Stack-bl az ES regisztert, amint az elejn lementettk}
end;

function ROLXORString(const S: String; XORByte, ROLBit: Byte): String; Assembler;
asm
  push es {Elmenti az ES regisztert a Stack-ben}
  push ds {Elmenti az DS regisztert a Stack-ben}
  push di {Elmenti az DI regisztert a Stack-ben}
  push si {Elmenti az SI regisztert a Stack-ben}
  lds  si, S       {Betlti a DS, SI regiszterprba az S String memria cmt}
  les  di, @Result {Betlti a ES, DI regiszterprba az @Result String memria cmt
                     ebben a - @Result - vltozban addik vissza a fggvny visszatrse}

  xor  ch, ch      {kinullzza a CH regisztert. (olyan mint: mov ch, 00h)         }
  mov  cl, Byte Ptr ds:[si] {Betlti a CL regiszterbe az S String hosszt, S[0]-t }
  mov  bx, cx               {Elmenti az S String hosszt BX reg.ben, a ksbbiekre}
  cld        {a REP MOVSB 'msol mvelet'-hez belltja a Direction flag-ot.     }
  inc  cl    {Nveli a CL reg.t, mert a REP MOVSB-vel tmsoljuk a ES:DI cmre              }
             { DS:SI-n kezdd S String-et. s azrt nveltk eggyel a CL-t, mert nem csak a}
  rep  movsb { a String x db. karaktert msoljuk t, hanem a String hosszt is. S[0]-t is !}
  dec  di    {Cskkenti DI reg.t, mert a REP MOVSB a msols vgn, az eredeti ES:DI-t a String
               vgre - Length(S)+1 - lltotta Pascal-osan gy: ES:=Seg(S); DI:=Ofs(S)+Length(S)+1;}
  mov  ch, XORByte {CH reg.be tlti azt a szmot amivel XOR-ozni fogunk}
  mov  cl, ROLBit  {CL reg.be tlti azt a szmot amennyi bit-tel jobbra forgatjuk a String karaktert}
@Codeing:          {ide ugrik vissza a kdols sorn az algoritmus}
  rol  Byte Ptr es:[di], cl {3: ROL-olja az ES:DI-n lv karaktert CL bit-tel - jobbra -   }
  xor  Byte Ptr es:[di], bl {2: meg-XOR-ozza az ES:DI-n lv karaktert BL-lel a String-ben lv pozcival}
  xor  Byte Ptr es:[di], ch {1: meg-XOR-ozza az ES:DI-n lv karaktert CH-val (XORByte-tal)}
  dec  di {Cskkenti a DI-t, s BL-t eggyel, mert a String-ben visszafel csinljuk a kdolst, valahogy  }
  dec  bl { gy: BL:=Length(S); S[BL]:=kdolt(S[BL]); (formakplet, nem utasts !)        }
  cmp  bl, 00h  {Vizsglat: elrtk -e a String elejt ? Azaz a BL a kezdeti - BL:=Length(S) - rtkt    }
  jne  @Codeing { a kdodls sorn cskkentve elrtk -e a 0-t ?            }
  pop  si {Kiemeli a Stack-bl az SI regisztert, amint az elejn lementettk}
  pop  di {Kiemeli a Stack-bl az DI regisztert, amint az elejn lementettk}
  pop  ds {Kiemeli a Stack-bl az DS regisztert, amint az elejn lementettk}
  pop  es {Kiemeli a Stack-bl az ES regisztert, amint az elejn lementettk}
end;

var S: String;
BEGIN
  S:='Black Cat kdol algoritmus !';
  S:=XORRORString(S, 144, 3);  {Bekdoljuk az S String-et, XOR-ozzuk 144-gyel,
}  WriteLn(S);
 {                               s jobbra forgatjuk 3 bit-tel}
  S:=RORXORString(S, 144, 8-3);{Ez mr a visszakdols, a function-ben elszr
   ROR-oljuk 8-3 bittel, gy visszaprdl az eredetibe a Byte-t, majd XORozzuk
   144-gyel.}
  WriteLn(S);
  S:='Black Cat kdol algoritmus !';
  S:=XORRORString(S, 144, 3);  {Bekdoljuk az S String-et, XOR-ozzuk 144-gyel,
                                s jobbra forgatjuk 3 bit-tel}
  WriteLn(S);


  {Itt sajt programunkban azt csinlunk a lekdolt String-gel amit akarunk
   le/fel/szt/ssze/oda/vissza mentjk file-ba, EXE-be fordtjuk stb.}


  S:=ROLXORString(S, 144, 3);  {Ez mr a visszakdols, a function-ben elszr
   ROL-oljuk 3 bittel, gy visszaprdl az eredetibe a Byte-t, majd XORozzuk
   144-gyel.}
  WriteLn(S);
END.
(*Ha a csak a 'fejlett' XOR-olst hasznljuk akkor mindegy, hogy elszr a
 XORByte-tal, vagy az indexxel XOR-ozunk. Teht a ugyanazt a function-t
 hasznlhatjuk a be ill. visszakdolsra.
 A fenti XORRORString Pascal-os megfelelje:

********************************Pascal-os forma******************************
{$G+}
function  RORByte(B, Value: Byte): Byte; Assembler;
asm
  mov  al, B
  mov  cl, Value
  ror  al, cl
end;

function  ROLByte(B, Value: Byte): Byte; Assembler;
asm
  mov  al, B
  mov  cl, Value
  rol  al, cl
end;

function XORRORString(S: String; XORByte, RORBit: Byte): String;
var i: Byte;
begin
  for i:=1 to Length(S) do
    S[i]:=Chr( RORByte( ( Ord(S[i]) XOR XORByte XOR i ), RORBit ));
  XORRORString:=S;
end;

function RORXORString(S: String; XORByte, RORBit: Byte): String;
var i: Byte;
begin
  for i:=1 to Length(S) do
    S[i]:=Chr( RORByte( Ord(S[i]), RORBit) XOR XORByte XOR i );
  RORXORString:=S;
end;

function ROLXORString(S: String; XORByte, ROLBit: Byte): String;
var i: Byte;
begin
  for i:=1 to Length(S) do
    S[i]:=Chr( ROLByte( Ord(S[i]), ROLBit) XOR XORByte XOR i );
  ROLXORString:=S;
end;

var S: String;
BEGIN
  S:='Black Cat kdol algoritmus !';
  S:=XORRORString(S, 144, 3);  {Bekdoljuk az S String-et, XOR-ozzuk 144-gyel,
                                s jobbra forgatjuk 3 bit-tel}
  S:=RORXORString(S, 144, 8-3);{Ez mr a visszakdols, a function-ben elszr
   ROR-oljuk 8-3 bittel, gy visszaprdl az eredetibe a Byte-t, majd XORozzuk
   144-gyel.}
  WriteLn(S);
  S:='Black Cat kdol algoritmus !';
  S:=XORRORString(S, 144, 3);  {Bekdoljuk az S String-et, XOR-ozzuk 144-gyel,
                                s jobbra forgatjuk 3 bit-tel}
  S:=ROLXORString(S, 144, 3);  {Ez mr a visszakdols, a function-ben elszr
   ROL-oljuk 3 bittel, gy visszaprdl az eredetibe a Byte-t, majd XORozzuk
   144-gyel.}
  WriteLn(S);
END.
***********************************vge**************************************



Egyb kdolsok:

********************************ASCIIPushString******************************
{A karakter ASCII kdjhoz ad egy szmot ...}
function  ASCIIPushString(StrToPush: String; NumWithPush: Integer): String;
var i: Byte;
begin
  if NumWithPush >  255 then NumWithPush:=NumWithPush Div 256;
  if NumWithPush < -255 then NumWithPush:=NumWithPush Div 256;
  for i:=1 to Length(StrToPush) do
    StrToPush[i]:= Chr(Ord(StrToPush[i]) + NumWithPush);
  ASCIIPushString:=StrToPush;
end;

var S: String;
BEGIN
  S:='PC-X User';
  S:=ASCIIPushString(S, 3);
  S:=ASCIIPushString(S, -3);
  WriteLn(S);
END.
***********************************vge**************************************



********************************XORExtended String***************************
{A 'fejlettebb' XOR-ols, assembly-ben.}
function XORExtendedString(const S: String; XORByte: Byte): String; Assembler;
asm
  push es {Elmenti az ES regisztert a Stack-ben}
  push ds {Elmenti az DS regisztert a Stack-ben}
  push di {Elmenti az DI regisztert a Stack-ben}
  push si {Elmenti az SI regisztert a Stack-ben}
  lds  si, S       {Betlti a DS, SI regiszterprba az S String memria cmt}
  les  di, @Result {Betlti a ES, DI regiszterprba az @Result String memria cmt
                     ebben a - @Result - vltozban addik vissza a fggvny visszatrse}

  xor  ch, ch      {kinullzza a CH regisztert. (olyan mint: mov ch, 00h)         }
  mov  cl, Byte Ptr ds:[si] {Betlti a CL regiszterbe az S String hosszt, S[0]-t }
  mov  bx, cx               {Elmenti az S String hosszt BX reg.ben, a ksbbiekre}
  cld        {a REP MOVSB 'msol mvelet'-hez belltja a Direction flag-ot.     }
  inc  cl    {Nveli a CL reg.t, mert a REP MOVSB-vel tmsoljuk a ES:DI cmre              }
             { DS:SI-n kezdd S String-et. s azrt nveltk eggyel a CL-t, mert nem csak a}
  rep  movsb { a String x db. karaktert msoljuk t, hanem a String hosszt is. S[0]-t is !}
  dec  di    {Cskkenti DI reg.t, mert a REP MOVSB a msols vgn, az eredeti ES:DI-t a String
               vgre - Length(S)+1 - lltotta Pascal-osan gy: ES:=Seg(S); DI:=Ofs(S)+Length(S)+1;}
  mov  ch, XORByte {CH reg.be tlti azt a szmot amivel XOR-ozni fogunk}
@Codeing:          {ide ugrik vissza a kdols sorn az algoritmus}
  xor  Byte Ptr es:[di], ch {meg-XOR-ozza az ES:DI-n lv karaktert CH-val (XORByte-tal)}
  xor  Byte Ptr es:[di], bl {meg-XOR-ozza az ES:DI-n lv karaktert BL-lel a String-ben lv pozcival}
  dec  di {Cskkenti a DI-t, s BL-t eggyel, mert a String-ben visszafel csinljuk a kdolst, valahogy  }
  dec  bl { gy: BL:=Length(S); S[BL]:=kdolt(S[BL]); (formakplet, nem utasts !)        }
  cmp  bl, 00h  {Vizsglat: elrtk -e a String elejt ? Azaz a BL a kezdeti - BL:=Length(S) - rtkt    }
  jne  @Codeing { a kdodls sorn cskkentve elrtk -e a 0-t ?            }
  pop  si {Kiemeli a Stack-bl az SI regisztert, amint az elejn lementettk}
  pop  di {Kiemeli a Stack-bl az DI regisztert, amint az elejn lementettk}
  pop  ds {Kiemeli a Stack-bl az DS regisztert, amint az elejn lementettk}
  pop  es {Kiemeli a Stack-bl az ES regisztert, amint az elejn lementettk}
end;

var S: String;
BEGIN
  S:='PC-X User';
  S:=XORExtendedString(S, 144);
  S:=XORExtendedString(S, 144);
  WriteLn(S);
END.
***********************************vge**************************************




****************************A kdols hasznlata prg.ben*********************
function XORExtendedString(const S: String; XORByte: Byte): String; Assembler;
asm
  push es {Elmenti az ES regisztert a Stack-ben}
  push ds {Elmenti az DS regisztert a Stack-ben}
  push di {Elmenti az DI regisztert a Stack-ben}
  push si {Elmenti az SI regisztert a Stack-ben}
  lds  si, S       {Betlti a DS, SI regiszterprba az S String memria cmt}
  les  di, @Result {Betlti a ES, DI regiszterprba az @Result String memria cmt
                     ebben a - @Result - vltozban addik vissza a fggvny visszatrse}

  xor  ch, ch      {kinullzza a CH regisztert. (olyan mint: mov ch, 00h)         }
  mov  cl, Byte Ptr ds:[si] {Betlti a CL regiszterbe az S String hosszt, S[0]-t }
  mov  bx, cx               {Elmenti az S String hosszt BX reg.ben, a ksbbiekre}
  cld        {a REP MOVSB 'msol mvelet'-hez belltja a Direction flag-ot.     }
  inc  cl    {Nveli a CL reg.t, mert a REP MOVSB-vel tmsoljuk a ES:DI cmre              }
             { DS:SI-n kezdd S String-et. s azrt nveltk eggyel a CL-t, mert nem csak a}
  rep  movsb { a String x db. karaktert msoljuk t, hanem a String hosszt is. S[0]-t is !}
  dec  di    {Cskkenti DI reg.t, mert a REP MOVSB a msols vgn, az eredeti ES:DI-t a String
               vgre - Length(S)+1 - lltotta Pascal-osan gy: ES:=Seg(S); DI:=Ofs(S)+Length(S)+1;}
  mov  ch, XORByte {CH reg.be tlti azt a szmot amivel XOR-ozni fogunk}
@Codeing:          {ide ugrik vissza a kdols sorn az algoritmus}
  xor  Byte Ptr es:[di], ch {meg-XOR-ozza az ES:DI-n lv karaktert CH-val (XORByte-tal)}
  xor  Byte Ptr es:[di], bl {meg-XOR-ozza az ES:DI-n lv karaktert BL-lel a String-ben lv pozcival}
  dec  di {Cskkenti a DI-t, s BL-t eggyel, mert a String-ben visszafel csinljuk a kdolst, valahogy  }
  dec  bl { gy: BL:=Length(S); S[BL]:=kdolt(S[BL]); (formakplet, nem utasts !)        }
  cmp  bl, 00h  {Vizsglat: elrtk -e a String elejt ? Azaz a BL a kezdeti - BL:=Length(S) - rtkt    }
  jne  @Codeing { a kdodls sorn cskkentve elrtk -e a 0-t ?            }
  pop  si {Kiemeli a Stack-bl az SI regisztert, amint az elejn lementettk}
  pop  di {Kiemeli a Stack-bl az DI regisztert, amint az elejn lementettk}
  pop  ds {Kiemeli a Stack-bl az DS regisztert, amint az elejn lementettk}
  pop  es {Kiemeli a Stack-bl az ES regisztert, amint az elejn lementettk}
end;

var S: String;
BEGIN
  S:='˹9=';
  WriteLn(XORExtendedString(S, 144));
END.
***********************************vge**************************************

*********************************Elzhz************************************
{Hogyan rakjuk programunkba ezt: S:='˹9='; ?}

function XORExtendedString(const S: String; XORByte: Byte): String; Assembler;
asm
  push es {Elmenti az ES regisztert a Stack-ben}
  push ds {Elmenti az DS regisztert a Stack-ben}
  push di {Elmenti az DI regisztert a Stack-ben}
  push si {Elmenti az SI regisztert a Stack-ben}
  lds  si, S       {Betlti a DS, SI regiszterprba az S String memria cmt}
  les  di, @Result {Betlti a ES, DI regiszterprba az @Result String memria cmt
                     ebben a - @Result - vltozban addik vissza a fggvny visszatrse}

  xor  ch, ch      {kinullzza a CH regisztert. (olyan mint: mov ch, 00h)         }
  mov  cl, Byte Ptr ds:[si] {Betlti a CL regiszterbe az S String hosszt, S[0]-t }
  mov  bx, cx               {Elmenti az S String hosszt BX reg.ben, a ksbbiekre}
  cld        {a REP MOVSB 'msol mvelet'-hez belltja a Direction flag-ot.     }
  inc  cl    {Nveli a CL reg.t, mert a REP MOVSB-vel tmsoljuk a ES:DI cmre              }
             { DS:SI-n kezdd S String-et. s azrt nveltk eggyel a CL-t, mert nem csak a}
  rep  movsb { a String x db. karaktert msoljuk t, hanem a String hosszt is. S[0]-t is !}
  dec  di    {Cskkenti DI reg.t, mert a REP MOVSB a msols vgn, az eredeti ES:DI-t a String
               vgre - Length(S)+1 - lltotta Pascal-osan gy: ES:=Seg(S); DI:=Ofs(S)+Length(S)+1;}
  mov  ch, XORByte {CH reg.be tlti azt a szmot amivel XOR-ozni fogunk}
@Codeing:          {ide ugrik vissza a kdols sorn az algoritmus}
  xor  Byte Ptr es:[di], ch {meg-XOR-ozza az ES:DI-n lv karaktert CH-val (XORByte-tal)}
  xor  Byte Ptr es:[di], bl {meg-XOR-ozza az ES:DI-n lv karaktert BL-lel a String-ben lv pozcival}
  dec  di {Cskkenti a DI-t, s BL-t eggyel, mert a String-ben visszafel csinljuk a kdolst, valahogy  }
  dec  bl { gy: BL:=Length(S); S[BL]:=kdolt(S[BL]); (formakplet, nem utasts !)        }
  cmp  bl, 00h  {Vizsglat: elrtk -e a String elejt ? Azaz a BL a kezdeti - BL:=Length(S) - rtkt    }
  jne  @Codeing { a kdodls sorn cskkentve elrtk -e a 0-t ?            }
  pop  si {Kiemeli a Stack-bl az SI regisztert, amint az elejn lementettk}
  pop  di {Kiemeli a Stack-bl az DI regisztert, amint az elejn lementettk}
  pop  ds {Kiemeli a Stack-bl az DS regisztert, amint az elejn lementettk}
  pop  es {Kiemeli a Stack-bl az ES regisztert, amint az elejn lementettk}
end;

var
  S: String;
  T: Text;
BEGIN
  Assign(T, 'KODOLT.pas');
  Rewrite(T);
  S:='KDOLAND STRING';
  WriteLn(T, XORExtendedString(S, 144));
  Close(T);
END.
{Majd nyissuk meg a 'kodolt.pas' file-t F3-mal, s rakjuk az S:=''; idzjelei
 kz, az ezt megelz programba !}
{FIGYELEM HA A KDOLT String ' jelet tartalmaz akkor az S String idzjelei
 kz gy rjuk S:='kodoltrizsa''idezojel'; !!!}
***********************************vge**************************************
*)